#include "grpmonstre.h"
#include <string.h>
#include <assert.h>
/** Fonction Get **/

Perso* GetAdresseMonstre(GrpMonstre * G, int IndiceMonstre)
{
    return &G->Groupe[IndiceMonstre];
}

int GetTailleGrpMonstre(GrpMonstre * G)
{
  return G->tailleutilise;
}

int GetPointDeVieMonstre(GrpMonstre * G, int IndiceMonstre)
{
  return GetPointDeViePerso(&G->Groupe[IndiceMonstre]);
}

int GetVieMaxMonstre(GrpMonstre * G, int IndiceMonstre)
{
  return getViemaxPerso(&G->Groupe[IndiceMonstre]);
}

int GetPosintxMonstre(GrpMonstre * G, int IndiceMonstre)
{
  return GetPosintxPerso(&G->Groupe[IndiceMonstre]);
}

int GetPosintyMonstre(GrpMonstre * G, int IndiceMonstre)
{
  return GetPosintyPerso(&G->Groupe[IndiceMonstre]);
}

double GetPosdoubxMonstre(GrpMonstre * G, int IndiceMonstre)
{
  return GetPosdoubxPerso(&G->Groupe[IndiceMonstre]);
}

double GetPosdoubyMonstre(GrpMonstre * G, int IndiceMonstre)
{
  return GetPosdoubyPerso(&G->Groupe[IndiceMonstre]);
}

char GetEtatMonstre(GrpMonstre * G, int IndiceMonstre)
{
  return GetEtatPerso(&G->Groupe[IndiceMonstre]);
}

double GetVectVitessexMonstre(GrpMonstre * G, int IndiceMonstre)
{
  return GetVectVitessexPerso(&G->Groupe[IndiceMonstre]);
}

double GetVectVitesseyMonstre(GrpMonstre * G, int IndiceMonstre)
{
  return GetVectVitesseyPerso(&G->Groupe[IndiceMonstre]);
}

Objet* GetObjetprincipMonstre(GrpMonstre * G, int IndiceMonstre)
{
  return GetObjetprincipPerso(&G->Groupe[IndiceMonstre]);
}

Objet* GetObjetsecondMonstre(GrpMonstre * G, int IndiceMonstre)
{
  return GetObjetsecondPerso(&G->Groupe[IndiceMonstre]);
}

typepers GetTypeMonstre(GrpMonstre * G, int IndiceMonstre)
{
  return GetTypePerso(&G->Groupe[IndiceMonstre]);
}

int GethitboxxMonstre(GrpMonstre * G, int IndiceMonstre)
{
    return GethitboxxPerso(&G->Groupe[IndiceMonstre]);
}

int GethitboxyMonstre(GrpMonstre * G, int IndiceMonstre)
{
    return GethitboxyPerso(&G->Groupe[IndiceMonstre]);
}

int GetVitesseMaxMonstre(GrpMonstre * G, int IndiceMonstre)
{
    return GetVitmaxPerso(&G->Groupe[IndiceMonstre]);
}

float GetTimerMonstre(GrpMonstre * G, int IndiceMonstre)
{
    return GetTimerPerso(&G->Groupe[IndiceMonstre]);
}

float GetTimer2Monstre(GrpMonstre * G, int IndiceMonstre)
{
    return GetTimer2Perso(&G->Groupe[IndiceMonstre]);
}

/** Fonction Set **/


void SethitboxMonstre(GrpMonstre * G, int IndiceMonstre, int x, int y)
{
    SethitboxPerso(&G->Groupe[IndiceMonstre],x,y);
}

void SetVieMaxMonstre(GrpMonstre * G, int IndiceMonstre, int pvmax)
{
  SetVieMaxPerso(&G->Groupe[IndiceMonstre], pvmax);
}

void SetPointDeVieMonstre(GrpMonstre * G, int IndiceMonstre, int pv)
{
  SetPointDeViePerso(&G->Groupe[IndiceMonstre], pv);
}

void SetPosintxMonstre(GrpMonstre * G, int IndiceMonstre, int x)
{
  SetPosintxPerso(&G->Groupe[IndiceMonstre], x);
}

void SetPosintyMonstre(GrpMonstre * G, int IndiceMonstre, int y)
{
  SetPosintyPerso(&G->Groupe[IndiceMonstre], y);
}

void SetPosdoubxMonstre(GrpMonstre * G, int IndiceMonstre, double x)
{
  SetPosdoubxPerso(&G->Groupe[IndiceMonstre], x);
}

void SetPosdoubyMonstre(GrpMonstre * G, int IndiceMonstre, double y)
{
  SetPosdoubyPerso(&G->Groupe[IndiceMonstre], y);
}

void SetEtatMonstre(GrpMonstre * G, int IndiceMonstre, char Etat)
{
  SetEtatPerso(&G->Groupe[IndiceMonstre], Etat);
}

void SetTypeMonstre(GrpMonstre * G, int IndiceMonstre, typepers T)
{
  SetTypePerso(&G->Groupe[IndiceMonstre], T);
}

void SetVitesseMaxMonstre(GrpMonstre * G, int IndiceMonstre, int VitMax)
{
  SetVitesseMax(&G->Groupe[IndiceMonstre], VitMax);
}

void SetVectVitesseMonstre(GrpMonstre * G, int IndiceMonstre, double x, double y)
{
    SetVectVitessePerso(&G->Groupe[IndiceMonstre],x,y);
}

void SetTimerMonstre(GrpMonstre * G, int IndiceMonstre)
{
    SetTimerPerso(&G->Groupe[IndiceMonstre]);
}

void SetTimer2Monstre(GrpMonstre * G, int IndiceMonstre)
{
    SetTimer2Perso(&G->Groupe[IndiceMonstre]);
}

GrpMonstre * InitGrpMonstre(int taillemax)
{
  GrpMonstre * G=NULL;
  G = malloc(sizeof(GrpMonstre));
  G->tailleutilise = 0;
  G->taillemax = taillemax;
  G->Groupe = malloc(taillemax * sizeof(Perso));
  G->prempoulemorte=0;
  assert(G!=NULL);
  return G;
}

void AjouterGrpMonstre(GrpMonstre * G, Perso * Monstre)
{
  if (G->tailleutilise < G->taillemax)
  {
    memcpy(&G->Groupe[G->tailleutilise], Monstre, sizeof(Perso));
    if (GetObjetprincipPerso(Monstre))
    {
        G->Groupe[G->tailleutilise].Objet[0]=malloc(sizeof(Objet));
        copieObjet(G->Groupe[G->tailleutilise].Objet[0],GetObjetprincipPerso(Monstre));
    }
    if (GetObjetsecondPerso(Monstre))
    {
        G->Groupe[G->tailleutilise].Objet[1]=malloc(sizeof(Objet));
        copieObjet(G->Groupe[G->tailleutilise].Objet[1],GetObjetsecondPerso(Monstre));
    }
    G->tailleutilise++;
  }
}

void SupprGrpMonstre(GrpMonstre * G, int IndiceMonstre)
{
  int i;
  i = IndiceMonstre;
  TestamentMonstrePerso(&G->Groupe[i]);
  while (i < G->taillemax-1)
  {
    memcpy(&G->Groupe[i], &G->Groupe[i+1], sizeof(Perso));
    i++;
  }
  G->tailleutilise--;
}

void miseajourvectviteGrpMonstre(GrpMonstre * G,float intervalle)
{
    int i;
    for (i=0;i<G->tailleutilise;i++)
        miseajourvectvitePerso(&G->Groupe[i],intervalle);
}

void TestamentGrpMonstre(GrpMonstre * G)
{
  free(G->Groupe);
  G->tailleutilise = 0;
  G->taillemax = 0;
  free(G);
}

double nouvellepositionxMonstre(GrpMonstre * G, int IndiceMonstre, float intervalle)
{
    return nouvellepositionxPerso(&G->Groupe[IndiceMonstre],intervalle);
}

double nouvellepositionyMonstre(GrpMonstre * G, int IndiceMonstre, float intervalle)
{
    return nouvellepositionyPerso(&G->Groupe[IndiceMonstre],intervalle);
}

int PertedevieMonstre(GrpMonstre* G, int IndiceMonstre, int perte)
{
    SetPointDeViePerso(&G->Groupe[IndiceMonstre],GetPointDeViePerso(&G->Groupe[IndiceMonstre])-perte);
    if (GetTypeMonstre(G,IndiceMonstre)==LARVEBOSS)
    {
        G->Groupe[IndiceMonstre].temps=0;
    }
    if (GetPointDeViePerso(&G->Groupe[IndiceMonstre])<=0)
    {
        if((GetTypeMonstre(G, IndiceMonstre) == POULE)&&(G->prempoulemorte == 0))
        {
            G->prempoulemorte=1;

        }
        SupprGrpMonstre(G,IndiceMonstre);
        return 1;
    }
    return 0;
}

int PointdansMonstre(GrpMonstre * G,int x, int y)
{
    int i;
    for (i=0;i<G->tailleutilise;i++)
        if (PointdansPerso(x,y,&G->Groupe[i]))
            return i;
    return -1;
}
